/* * Copyright (C) 2007-2008 OpenIntents.org * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.ipaulpro.afilechooser.utils; import android.content.ContentResolver; import android.content.Context; import android.content.Intent; import android.content.res.XmlResourceParser; import android.database.Cursor; import android.graphics.Bitmap; import android.net.Uri; import android.provider.MediaStore; import android.provider.MediaStore.Audio; import android.provider.MediaStore.Video; import android.util.Log; import com.ipaulpro.afilechooser.R; import java.io.File; import java.io.FileFilter; import java.net.URISyntaxException; import java.text.DecimalFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.List; import java.util.Locale; /** * @version 2009-07-03 * * @author Peli * */ public class FileUtils { /** TAG for log messages. */ static final String TAG = "FileUtils"; private static final boolean DEBUG = false; // Set to true to enable logging public static final String MIME_TYPE_AUDIO = "audio/*"; public static final String MIME_TYPE_TEXT = "text/*"; public static final String MIME_TYPE_IMAGE = "image/*"; public static final String MIME_TYPE_VIDEO = "video/*"; public static final String MIME_TYPE_APP = "application/*"; /** * Whether the URI is a local one. * * @param uri * @return */ public static boolean isLocal(String uri) { return uri != null && !uri.startsWith("http://"); } /** * Gets the extension of a file name, like ".png" or ".jpg". * * @param uri * @return Extension including the dot("."); "" if there is no extension; * null if uri was null. */ public static String getExtension(String uri) { if (uri == null) { return null; } int dot = uri.lastIndexOf('.'); if (dot >= 0) { return uri.substring(dot); } else { // No extension. return ""; } } /** * Returns true if uri is a media uri. * * @param uri * @return */ public static boolean isMediaUri(Uri uri) { String uriString = uri.toString(); return uriString.startsWith(Audio.Media.INTERNAL_CONTENT_URI.toString()) || uriString.startsWith(Audio.Media.EXTERNAL_CONTENT_URI.toString()) || uriString.startsWith(Video.Media.INTERNAL_CONTENT_URI.toString()) || uriString.startsWith(Video.Media.EXTERNAL_CONTENT_URI.toString()); } /** * Convert File into Uri. * @param file * @return uri */ public static Uri getUri(File file) { if (file != null) { return Uri.fromFile(file); } return null; } /** * Convert Uri into File. * @param uri * @return file */ public static File getFile(Uri uri) { if (uri != null) { String filepath = uri.getPath(); if (filepath != null) { return new File(filepath); } } return null; } /** * Returns the path only (without file name). * @param file * @return */ public static File getPathWithoutFilename(File file) { if (file != null) { if (file.isDirectory()) { // no file to be split off. Return everything return file; } else { String filename = file.getName(); String filepath = file.getAbsolutePath(); // Construct path without file name. String pathwithoutname = filepath.substring(0, filepath.length() - filename.length()); if (pathwithoutname.endsWith("/")) { pathwithoutname = pathwithoutname.substring(0, pathwithoutname.length() - 1); } return new File(pathwithoutname); } } return null; } /** * Constructs a file from a path and file name. * * @param curdir * @param file * @return */ public static File getFile(String curdir, String file) { String separator = "/"; if (curdir.endsWith("/")) { separator = ""; } return new File(curdir + separator + file); } public static File getFile(File curdir, String file) { return getFile(curdir.getAbsolutePath(), file); } /** * Get a file path from a Uri. * * @param context * @param uri * @return * @throws URISyntaxException * * @author paulburke */ public static String getPath(Context context, Uri uri) throws URISyntaxException { if(DEBUG) Log.d(TAG+" File -", "Authority: " + uri.getAuthority() + ", Fragment: " + uri.getFragment() + ", Port: " + uri.getPort() + ", Query: " + uri.getQuery() + ", Scheme: " + uri.getScheme() + ", Host: " + uri.getHost() + ", Segments: " + uri.getPathSegments() ); if ("content".equalsIgnoreCase(uri.getScheme())) { String[] projection = { "_data" }; Cursor cursor = null; try { cursor = context.getContentResolver().query(uri, projection, null, null, null); int column_index = cursor .getColumnIndexOrThrow("_data"); if (cursor.moveToFirst()) { String ci = cursor.getString(column_index); cursor.close(); return ci; } } catch (Exception e) { // Eat it } if (cursor != null) { cursor.close(); } } else if ("file".equalsIgnoreCase(uri.getScheme())) { return uri.getPath(); } return null; } /** * Get the file size in a human-readable string. * * @param size * @return * * @author paulburke */ public static String getReadableFileSize(int size) { final int BYTES_IN_KILOBYTES = 1024; final DecimalFormat dec = new DecimalFormat("###.#"); final String KILOBYTES = " KB"; final String MEGABYTES = " MB"; final String GIGABYTES = " GB"; float fileSize = 0; String suffix = KILOBYTES; if (size > BYTES_IN_KILOBYTES) { fileSize = size/BYTES_IN_KILOBYTES; if (fileSize > BYTES_IN_KILOBYTES) { fileSize /= BYTES_IN_KILOBYTES; if (fileSize > BYTES_IN_KILOBYTES) { fileSize /= BYTES_IN_KILOBYTES; suffix = GIGABYTES; } else { suffix = MEGABYTES; } } } return String.valueOf(dec.format(fileSize)+suffix); } /** * Load MIME types from XML * * @param context * @return */ private static MimeTypes getMimeTypes(Context context) { MimeTypes mimeTypes = null; final MimeTypeParser mtp = new MimeTypeParser(); final XmlResourceParser in = context.getResources().getXml(R.xml.mimetypes); try { mimeTypes = mtp.fromXmlResource(in); } catch (Exception e) { if(DEBUG) Log.e(TAG, "getMimeTypes", e); } in.close(); return mimeTypes; } /** * Get the file MIME type * * @param context * @param file * @return */ public static String getMimeType(Context context, File file) { String mimeType = null; final MimeTypes mimeTypes = getMimeTypes(context); if (file != null) mimeType = mimeTypes.getMimeType(file.getName()); return mimeType; } /** * Attempt to retrieve the thumbnail of given File from the MediaStore. * * This should not be called on the UI thread. * * @param context * @param file * @return * * @author paulburke */ public static Bitmap getThumbnail(Context context, File file) { return getThumbnail(context, getUri(file), getMimeType(context, file)); } /** * Attempt to retrieve the thumbnail of given Uri from the MediaStore. * * This should not be called on the UI thread. * * @param context * @param uri * @return * * @author paulburke */ public static Bitmap getThumbnail(Context context, Uri uri) { return getThumbnail(context, uri, getMimeType(context, getFile(uri))); } /** * Attempt to retrieve the thumbnail of given Uri from the MediaStore. * * This should not be called on the UI thread. * * @param context * @param uri * @param mimeType * @return * * @author paulburke */ public static Bitmap getThumbnail(Context context, Uri uri, String mimeType) { if(DEBUG) Log.d(TAG, "Attempting to get thumbnail"); if (isMediaUri(uri)) { if (DEBUG) Log.e(TAG, "You can only retrieve thumbnails for images and videos."); return null; } Bitmap bm = null; if (uri != null) { final ContentResolver resolver = context.getContentResolver(); Cursor cursor = null; try { cursor = resolver.query(uri, null, null,null, null); if (cursor.moveToFirst()) { final int id = cursor.getInt(0); if(DEBUG) Log.d(TAG, "Got thumb ID: "+id); if (mimeType.contains("video")) { bm = Video.Thumbnails.getThumbnail( resolver, id, Video.Thumbnails.MINI_KIND, null); } else if (mimeType.contains(MIME_TYPE_IMAGE)) { bm = MediaStore.Images.Thumbnails.getThumbnail( resolver, id, MediaStore.Images.Thumbnails.MINI_KIND, null); } } } catch (Exception e) { if(DEBUG) Log.e(TAG, "getThumbnail", e); } finally { if (cursor != null) cursor.close(); } } return bm; } private static final String HIDDEN_PREFIX = "."; /** * File and folder comparator. * TODO Expose sorting option method * * @author paulburke */ private static final Comparator<File> mComparator = new Comparator<File>() { @Override public int compare(File f1, File f2) { // Sort alphabetically by lower case, which is much cleaner return f1.getName().toLowerCase(Locale.US).compareTo( f2.getName().toLowerCase(Locale.US)); } }; /** * File (not directories) filter. * * @author paulburke */ private static final FileFilter mFileFilter = new FileFilter() { @Override public boolean accept(File file) { final String fileName = file.getName(); // Return files only (not directories) and skip hidden files return file.isFile() && !fileName.startsWith(HIDDEN_PREFIX); } }; /** * Folder (directories) filter. * * @author paulburke */ private static final FileFilter mDirFilter = new FileFilter() { @Override public boolean accept(File file) { final String fileName = file.getName(); // Return directories only and skip hidden directories return file.isDirectory() && !fileName.startsWith(HIDDEN_PREFIX); } }; /** * Get a list of Files in the give path * * @param path * @return Collection of files in give directory * @author paulburke */ public static List<File> getFileList(String path) { ArrayList<File> list = new ArrayList<File>(); // Current directory File instance final File pathDir = new File(path); // List file in this directory with the directory filter final File[] dirs = pathDir.listFiles(mDirFilter); if (dirs != null) { // Sort the folders alphabetically Arrays.sort(dirs, mComparator); // Add each folder to the File list for the list adapter Collections.addAll(list, dirs); } // List file in this directory with the file filter final File[] files = pathDir.listFiles(mFileFilter); if (files != null) { // Sort the files alphabetically Arrays.sort(files, mComparator); // Add each file to the File list for the list adapter Collections.addAll(list, files); } return list; } /** * Get the Intent for selecting content to be used in an Intent Chooser. * * @return The intent for opening a file with Intent.createChooser() * * @author paulburke */ public static Intent createGetContentIntent() { // Implicitly allow the user to select a particular kind of data final Intent intent = new Intent(Intent.ACTION_GET_CONTENT); // The MIME data type filter intent.setType("*/*"); // Only return URIs that can be opened with ContentResolver intent.addCategory(Intent.CATEGORY_OPENABLE); return intent; } }